package demo4;

public class Test {

    public static void main(String[] args) {
        Animal animal=new Cat("xiaomao",30);
        //向下转型
        Cat cat=(Cat) animal;
        cat.mimi();

        Animal animal1=new Dog("wangcai",20);
        //如果animal1这个引用 引用的对象就是Cat
        if(animal1 instanceof Cat){
            Cat cat1=(Cat) animal1;
            cat1.mimi();
        }else{
            System.out.println("animal1 instanceof Cat not!!!");
        }
    }

    public static int add(int x,int y){
        return x+y;
    }
    public static double add(double x,double y,double z){
        return x+y+z;
    }
    public static void main4(String[] args) {
        //静态绑定
        //在编译时，根据用户所传递实参类型就确定了具体调用哪个方法，即为静态绑定，典型代表：重载
        add(12,3);
        add(1.6,2.5,3.9);
    }

    public static void func1(Animal animal){
        //animal引用的对象不一样，但是调用的是同一个方法，此时表现出的现象不一样，此时这种思想，就叫做多态
        animal.eat();
    }
    public static void main3(String[] args) {

        //多态实现条件
        //1.必须在继承体系下
        //2.子类必须要对父类中方法进行重写
        //3.通过父类的引用调用重写的方法
        Dog dog=new Dog("wangcai",123);
        func1(dog);
        Cat cat=new Cat("mimi",456);
        func1(cat);
    }


    public static void main2(String[] args) {
        Animal animal=new Dog("旺财",12);
        //动态绑定的条件
        //1.父类引用 引用 子类对象
        //2.通过父类引用，调用了父类和子类重写的那个方法(最后实际上调用的是子类的方法)

        //方法的重写，动态绑定
        //理论上来说应该调用父类animal的eat，但是事实上调用了子类Dog的eat
        animal.eat();
    }
    //2.方法传参
    public static void func(Animal animal){

    }
    public static Animal func2(){
        Dog dog=new Dog("hhh",26);

        return dog;
    }
    public static void main1(String[] args) {

        //向上转型，父类引用 引用了子类对象
        //向上转型的注意事项
        //1.通过父类的引用调用子类特有的方法是无法直接调用的，只能调用父类自己的方法
        //1.直接赋值
        Animal animal=new Dog("旺财",12);
        System.out.println(animal);

        //2.方法传参
        Dog dog=new Dog("小狗",11);
        func(dog);

        //3.方法返回值
        Animal animal1=func2();
        System.out.println(animal1);
    }
}
